package com.ruoyi.web.controller;

import com.alibaba.dashscope.aigc.generation.Generation;
import com.alibaba.dashscope.aigc.generation.GenerationParam;
import com.alibaba.dashscope.aigc.generation.GenerationResult;
import com.alibaba.dashscope.exception.InputRequiredException;
import com.alibaba.dashscope.exception.NoApiKeyException;
import com.ruoyi.system.domain.ChatResponse;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.memory.ChatMemory;
import org.springframework.ai.chat.messages.Message;
import org.springframework.ai.chat.messages.UserMessage;
import org.springframework.ai.chat.model.ChatModel;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

@RestController
@RequestMapping("/ai")
@CrossOrigin(origins = "*")  // 启用CORS跨域支持
public class ChatController {

    private final ChatClient chatClient;
    private final ChatMemory chatMemory;
    private final ChatModel chatModel;
    @Autowired
    public ChatController(ChatClient chatClient, ChatMemory chatMemory, ChatModel chatModel) {
        this.chatClient = chatClient;
        this.chatMemory = chatMemory;
        this.chatModel = chatModel;
    }


    @GetMapping("/steamChat")
    public ResponseEntity<ChatResponse> steamChat(@RequestParam String input) throws NoApiKeyException, InputRequiredException {
        try {
            // 创建用户消息
            UserMessage userMessage = new UserMessage(input);
            chatMemory.add("conversationId", List.of(userMessage));

            // 使用Generation类调用模型
            Generation gen = new Generation();
            GenerationParam param = GenerationParam
                    .builder()
                    .model("qwen1.5-32b-chat")
                    .prompt("Human: " + input + "\n\nAssistant:")
                    .build();
            GenerationResult result = gen.call(param);

            // 正确获取AI响应文本
            String aiMessage = result.getOutput().getText(); // 修改这里
            if (aiMessage == null || aiMessage.isEmpty()) {
                throw new RuntimeException("AI响应为空");
            }

            // 提取关键词和类型
            List<String> keywords = extractKeywords(aiMessage);
            String type = determineType(aiMessage);

            // 创建响应对象
            ChatResponse chatResponse = new ChatResponse(input, aiMessage, keywords, type);

            return ResponseEntity
                    .ok()
                    .contentType(MediaType.APPLICATION_JSON)
                    .body(chatResponse);

        } catch (Exception e) {
//            log.error("Chat处理失败", e);
            return ResponseEntity
                    .status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body(new ChatResponse(input, "处理请求时发生错误: " + e.getMessage(), null, "error"));
        }
    }
    private String determineType(String aiMessage) {
        if (aiMessage.contains("编程语言")) {
            return "编程语言";
        } else if (aiMessage.contains("框架")) {
            return "框架";
        }
        else if (aiMessage.contains("工具")) {
            return "工具";
        }
        else if (aiMessage.contains("Java") && aiMessage.contains("版本")) {
            return "语言版本";
        }
        else if (aiMessage.contains("Spring Boot") && aiMessage.contains("版本")) {
            return "框架版本";
        }
        // 可以根据需要添加更多的关键字检测逻辑
        return null;
    }

    private List<String> extractKeywords(String input) {
        List<String> keywords = new ArrayList<>();

        // 从chatMemory中获取之前存储的关键字
        List<String> existingKeywords = chatMemory.get("conversationId", 100).stream()
                .map(Message::getContent)
                .flatMap(content -> Arrays.stream(content.split(" "))) // 假设关键字之间用空格分隔
                .collect(Collectors.toList());

        // 当输入包含“编程语言”时，添加一系列编程语言
        if (input.contains("编程语言") && !existingKeywords.contains("编程语言")) {
            keywords.add("Java");
            keywords.add("Python");
            keywords.add("C++");
            keywords.add("JavaScript");
            // 可以根据需要添加更多编程语言
        }

        // 当输入包含“框架”时，添加一系列框架
        if (input.contains("框架")&& input.contains("编程语言") && !existingKeywords.contains("框架")) {
            keywords.add("Spring Boot");
            keywords.add("Django");
            keywords.add("React");
            keywords.add("Vue.js");
            // 可以根据需要添加更多框架
        }

        // 当输入包含“编程工具”时，添加一系列编程工具
        if (input.contains("工具") && !existingKeywords.contains("工具")) {
            keywords.add("IntelliJ IDEA");
            keywords.add("VSCode");
            keywords.add("PyCharm");
            keywords.add("WebStorm");
            keywords.add("Eclipse");
        }

        if (input.contains("Java") && input.contains("版本") && !existingKeywords.contains("Java")) {
            keywords.add("Java 8");
            keywords.add("Java 11");
            keywords.add("Java 17");
        }

        if (input.contains("Spring Boot") && input.contains("版本") ) {
            keywords.add("Spring Boot 2.3.x");
            keywords.add("Spring Boot 2.5.x");
            keywords.add("Spring Boot 2.6.x");
            keywords.add("Spring Boot 2.7.x");
        }

        return keywords;
    }
//    @GetMapping("/steamChat")
//    public Flux<String> steamChat(@RequestParam String input) {
//
//        // 创建用户消息
//        UserMessage userMessage = new UserMessage(input);
//
//        // 将用户消息添加到对话历史中
//        chatMemory.add("conversationId", List.of(userMessage));
//        // 假设有一个会话ID
//
//// 先调用函数获取结果
//        String functionResult = this.chatClient.prompt()
//                .user(input)
//                .call().content();
//
//// 将结果作为流式输出的一部分
//        return Flux.just(functionResult)
//                .concatWith(this.chatClient.prompt()
//                        .user(input)
//                        .advisors(a -> a.param(CHAT_MEMORY_RETRIEVE_SIZE_KEY, 100))
//                        .stream().content());
//    }
}





//   @GetMapping("/steamChat")
//    public ChatResponse steamChat(@RequestParam String input) {
//        // 创建用户消息
//        UserMessage userMessage = new UserMessage(input);
//
//        // 将用户消息添加到对话历史中
//        chatMemory.add("conversationId", List.of(userMessage));
//
//        // 获取AI响应
//        String aiMessage = this.chatClient.prompt()
//
//                .user(input)
//                .advisors(a -> a.param(CHAT_MEMORY_RETRIEVE_SIZE_KEY, 100))
//                .call().content();
//
//        // 提取关键词
//        List<String> keywords = extractKeywords(aiMessage);
//
//        // 根据AI生成的内容设置type属性的值
//        String type = determineType(aiMessage);
//
//        // 创建ChatResponse对象
//        ChatResponse chatResponse = new ChatResponse(input, aiMessage, keywords, type);
//
//        return chatResponse;
//    }
